package com.jichangxiu.framework.security.service;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.jichangxiu.common.constant.Constant;
import com.jichangxiu.common.entity.bo.SecurityRole;
import com.jichangxiu.common.entity.bo.SecurityUser;
import com.jichangxiu.common.utils.TokenUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

/**
 * PermissionService:
 *
 * @author Jcx
 * @create 2023-04-04 13:36
 */
@Service("ss")
public class PermissionService {

    /**
     * 所有权限标识
     */
    private static final String ALL_PERMISSION = "*:*:*";

    @Resource
    private TokenUtils tokenUtils;

    /**
     * 验证用户是否具备某权限
     *
     * @param permission 权限字符串
     * @return 用户是否具备某权限
     */
    public boolean hasPermission(String permission) {
        if (StrUtil.isEmpty(permission)) {
            return false;
        }
        SecurityUser securityUser = tokenUtils.getSecurityUser();
        if (ObjectUtil.isNull(securityUser) || ObjectUtil.isEmpty(securityUser.getAuthList())) {
            return false;
        }
        return hasPermission(securityUser.getAuthList(), permission);
    }

    /**
     * 验证用户是否不具备某权限，与 hasPermi逻辑相反
     *
     * @param permission 权限字符串
     * @return 用户是否不具备某权限
     */
    public boolean noPermission(String permission) {
        return !hasPermission(permission);
    }

    /**
     * 验证用户是否具有以下任意一个权限
     *
     * @param permissions 以 逗号 为分隔符的权限列表
     * @return 用户是否具有以下任意一个权限
     */
    public boolean hasAnyPermission(String permissions) {
        if (StrUtil.isEmpty(permissions)) {
            return false;
        }
        SecurityUser securityUser = tokenUtils.getSecurityUser();
        if (ObjectUtil.isNull(securityUser) || ObjectUtil.isEmpty(securityUser.getAuthList())) {
            return false;
        }
        List<String> permissionList = securityUser.getAuthList();
        for (String permission : permissions.split(",")) {
            if (StrUtil.isNotEmpty(permission) && hasPermission(permissionList, permission)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断是否包含权限
     *
     * @param permissionList 权限列表
     * @param permission     权限字符串
     * @return 用户是否具备某权限
     */
    private boolean hasPermission(List<String> permissionList, String permission) {
        return permissionList.contains(ALL_PERMISSION) || permissionList.contains(StrUtil.trim(permission));
    }

    /**
     * 判断用户是否拥有某个角色
     *
     * @param role 角色字符串
     * @return 用户是否具备某角色
     */
    public boolean hasRole(String role) {
        if (StrUtil.isEmpty(role)) {
            return false;
        }
        SecurityUser securityUser = tokenUtils.getSecurityUser();
        if (ObjectUtil.isNull(securityUser) || ObjectUtil.isEmpty(securityUser.getSecurityRoles())) {
            return false;
        }
        for (SecurityRole securityRole : securityUser.getSecurityRoles()) {
            String roleCode = securityRole.getAuthority();
            if ((Constant.PLATFORM_SUPER_ROLE.equals(roleCode) && securityRole.getIsPlatform()) || roleCode.equals(StrUtil.trim(role))) {
                return true;
            }
        }
        return false;
    }

    /**
     * 验证用户是否不具备某角色，与 isRole逻辑相反。
     *
     * @param role 角色名称
     * @return 用户是否不具备某角色
     */
    public boolean noRole(String role) {
        return !hasRole(role);
    }

    /**
     * 验证用户是否具有以下任意一个角色
     *
     * @param roles 以逗号为分隔符的角色列表
     * @return 用户是否具有以下任意一个角色
     */
    public boolean hasAnyRoles(String roles) {
        if (StrUtil.isEmpty(roles)) {
            return false;
        }
        SecurityUser securityUser = tokenUtils.getSecurityUser();
        if (ObjectUtil.isEmpty(securityUser) || ObjectUtil.isEmpty(securityUser.getSecurityRoles())) {
            return false;
        }
        for (String role : roles.split(",")) {
            if (hasRole(role)) {
                return true;
            }
        }
        return false;
    }

}
